#include "RecursoAlmacenamiento.h"
#include "EstrategiaRecurso.h"
#include "IndiceBSharp.h"
#include "Excepciones.h"

namespace Toolkit
{

RecursoAlmacenamiento::RecursoAlmacenamiento(Almacenamiento *primario,
        EstrategiaRecurso *estrategiaRecurso,
        EstrategiaAlmacenamiento *estrategiaAlmacenamiento, Indice *indice,
        Almacenamiento *secundario)
{
    this->primario = primario;
    this->secundario = secundario;

    estrategiaRecurso->setRecurso(this);
    this->estrategiaRecurso = estrategiaRecurso;

    this->indice = indice;
    this->estrategiaAlmacenamiento = estrategiaAlmacenamiento;
}

RecursoAlmacenamiento::~RecursoAlmacenamiento()
{
    delete estrategiaRecurso;
    delete estrategiaAlmacenamiento;

    if (indice != NULL) {
        delete indice;
    }

    if (secundario != NULL) {
        delete secundario;
    }

    delete primario;

}

void RecursoAlmacenamiento::guardarDato(const Dato &dato, const Clave &clave)
{
    estrategiaRecurso->guardarDato(dato, clave);
}

bool RecursoAlmacenamiento::recuperarDato(const Clave &clave, Dato &dato) const
{
    return estrategiaRecurso->recuperarDato(clave, dato);
}

void RecursoAlmacenamiento::eliminarDato(const Clave &clave, Dato &dato)
{
    estrategiaRecurso->eliminarDato(clave, dato);
}

void RecursoAlmacenamiento::actualizarDato(const Dato &dato, const Clave &clave)
{
    estrategiaRecurso->actualizarDato(dato, clave);
}

bool RecursoAlmacenamiento::bSharpGetSiguienteDato(Dato &dato,
        const Clave &clave) const
{
    Clave* claveSiguiente = NULL;
    IndiceBSharp* indiceAux = dynamic_cast<IndiceBSharp*> (this->indice);

    if (indiceAux != NULL) {
        if (indiceAux->getSiguienteClave(clave, claveSiguiente)) {
            return this->estrategiaRecurso->recuperarDato((*claveSiguiente), dato);
        }
    }
    else {
        throw new NoSeUsaBSharp();
    }

    return false;
}

void RecursoAlmacenamiento::setControlUnicidad(const bool& controlUnicidad)
{
    estrategiaRecurso->setControlUnicidad(controlUnicidad);
}

bool RecursoAlmacenamiento::getControlarUnicidad() const
{
    return estrategiaRecurso->getControlUnicidad();
}

}
